home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / disk utilities / backup / backup_restore / backup_src_v3.20.lha / Text.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-31  |  5.6 KB  |  305 lines
  1. // Text.c
  2. // 09 Jun 1996 12:19:15
  3.  
  4. #ifndef    BACKUP_INCLUDE
  5. #include "IncludeAll.c"
  6. #endif
  7. #include "Backup.h"
  8. #include "Backup_proto.h"
  9.  
  10. #define    CATCOMP_ARRAY
  11. #include "BackupStrings.h"
  12. #undef    STRINGARRAY
  13.  
  14. static ULONG __saveds __asm DateStrHook(register __a0 struct Hook *theHook,
  15.         register __a1 char NextChar,
  16.         register __a2 struct Locale *myLocale);
  17. static ULONG __saveds __asm ReadDateHook(register __a0 struct Hook *theHook,
  18.         register __a1 struct Locale *myLocale);
  19.  
  20.  
  21. // aus Backup_Window.c
  22. extern struct Library *LocaleBase;
  23. extern struct Library *UtilityBase;
  24.  
  25.  
  26. static struct Catalog *li_Catalog;
  27. struct Locale *myLocale;
  28.  
  29.  
  30. void myOpenLocale(const char *Language)
  31. {
  32.     if (UtilityBase && LocaleBase)
  33.         {
  34.         li_Catalog = OpenCatalog(NULL, (STRPTR) "backup.catalog",
  35.                 OC_BuiltInLanguage, (STRPTR) "deutsch",
  36.                 *Language ? OC_Language : TAG_IGNORE, (STRPTR) Language,
  37.                 TAG_END );
  38.  
  39.         myLocale = OpenLocale(NULL);
  40.  
  41.         if (NULL == li_Catalog)
  42.             {
  43.             // Catalog kann nicht geöffnet werden ... warum auch immer
  44.             }
  45.         else if (li_Catalog->cat_Version != VERSION || li_Catalog->cat_Revision != REVISION)
  46.             {
  47.             alarm(GetString(MSG_WRONG_CATALOG_VERSION),
  48.                 li_Catalog->cat_Version, li_Catalog->cat_Revision,
  49.                 VERSION, REVISION);
  50.  
  51.             CloseCatalog(li_Catalog);
  52.             li_Catalog = NULL;
  53.             }
  54.         }
  55. }
  56.  
  57.  
  58. void myCloseLocale(void)
  59. {
  60.     if (myLocale)
  61.         CloseLocale(myLocale);
  62.     if (li_Catalog)
  63.         CloseCatalog(li_Catalog);
  64.  
  65.     li_Catalog = NULL;
  66.     myLocale = NULL;
  67. }
  68.  
  69.  
  70. const char *GetString(long id)
  71. {
  72.     struct CatCompArrayType *as;
  73.     const char *s = "";
  74.     short k,l;
  75.  
  76.     l = sizeof(CatCompArray) / sizeof(CatCompArray[0]);
  77.     as = CatCompArray;
  78.     for(k=0; k<l; k++, as++)
  79.         {
  80.         if(as->cca_ID == id)
  81.             {
  82.             s = as->cca_Str;
  83.             break;
  84.             }
  85.         }
  86.  
  87.     if (li_Catalog && *s)
  88.         s = GetCatalogStr(li_Catalog, id, (STRPTR) s);
  89.  
  90.     return(s);
  91. }
  92.  
  93.  
  94. char GetDecimalPoint(void)
  95. {
  96.     return (char) (myLocale ? *myLocale->loc_DecimalPoint : '.');
  97. }
  98.  
  99.  
  100. static ULONG __saveds __asm DateStrHook(register __a0 struct Hook *theHook,
  101.         register __a1 char NextChar,
  102.         register __a2 struct Locale *myLocale)
  103. {
  104.     char **p;
  105.  
  106.     p = (char **) &theHook->h_Data;
  107.     *(*p)++ = NextChar;
  108.  
  109.     return 0L;
  110. }
  111.  
  112.  
  113. static ULONG __saveds __asm ReadDateHook(register __a0 struct Hook *theHook,
  114.         register __a1 struct Locale *myLocale)
  115. {
  116.     char c, **p;
  117.  
  118.     p = (char **) &theHook->h_Data;
  119.     c = isspace(**p) ? '\0' : **p;
  120.     (*p)++;
  121.     return (ULONG) c;
  122. }
  123.  
  124.  
  125. char *DateString(short Tag, short Monat, short Jahr)
  126. {
  127.     static char res[80];
  128.     struct DateStamp ds;
  129.     struct Hook myHook;
  130.  
  131.     if (myLocale)
  132.         {
  133.         ds.ds_Days = PackDate(Tag, Monat, Jahr);
  134.         ds.ds_Minute = 0l;
  135.         ds.ds_Tick = 0l;
  136.  
  137.         myHook.h_Entry = (unsigned long (*)()) DateStrHook;
  138.         myHook.h_Data = res;
  139.  
  140.         FormatDate(myLocale, myLocale->loc_ShortDateFormat, &ds, &myHook);
  141.         }
  142.     else
  143.         {
  144.         sprintf(res, "%2d.%02d.%02d", Tag, Monat, Jahr);
  145.         }
  146.  
  147.     return res;
  148. }
  149.  
  150.  
  151. char *TimeString(short Stunde, short Minute, short Sekunde)
  152. {
  153.     static char res[80];
  154.     struct DateStamp ds;
  155.     struct Hook myHook;
  156.  
  157.     if (myLocale)
  158.         {
  159.         ds.ds_Days = 0;
  160.         ds.ds_Minute = Stunde * 60 + Minute;
  161.         ds.ds_Tick = Sekunde * TICKS_PER_SECOND;
  162.  
  163.         myHook.h_Entry = (unsigned long (*)()) DateStrHook;
  164.         myHook.h_Data = res;
  165.  
  166.         FormatDate(myLocale, myLocale->loc_ShortTimeFormat, &ds, &myHook);
  167.         }
  168.     else
  169.         {
  170.         sprintf(res, "%2d:%02d:%02d", Stunde, Minute, Sekunde);
  171.         }
  172.  
  173.     return res;
  174. }
  175.  
  176.  
  177. // Datum aus String lesen und in Tagesnummer (long, ab 1.1.1978) umwandeln
  178. // liefert 0 bei Fehler im Datum
  179. long ReadDate(const char *str)
  180. {
  181.     const char *origStr;
  182.     long tagnr;
  183.     short Tag, Monat, Jahr;
  184.  
  185.     ASSERT_VALID(str);
  186.     if (myLocale)
  187.         {
  188.         struct DateStamp ds;
  189.         struct Hook myHook;
  190.  
  191.         myHook.h_Entry = (unsigned long (*)()) ReadDateHook;
  192.         myHook.h_Data = (char *) str;
  193.  
  194.         if (ParseDate(myLocale, &ds, myLocale->loc_ShortDateFormat, &myHook))
  195.             tagnr = ds.ds_Days;
  196.         else
  197.             tagnr = ~0L;
  198.         }
  199.     else
  200.         {
  201.         origStr = str;
  202.  
  203.         Tag = myatoi(&str, 2);        // Tag holen
  204.  
  205.         while (*str && !isdigit(*str))
  206.             str++;
  207.         Monat = myatoi(&str, 2);    // Monat holen
  208.  
  209.         while (*str && !isdigit(*str))
  210.             str++;
  211.         Jahr = myatoi(&str, 4);        // Jahr holen
  212.  
  213.         tagnr = PackDate(Tag, Monat, Jahr);
  214.         }
  215.  
  216.     if (tagnr == ~0l)
  217.         {
  218.         alarm(GetString(MSG_INVALID_DATE), origStr);
  219.         tagnr = 0;
  220.         }
  221.  
  222.     return tagnr;
  223. }
  224.  
  225. // toupper() und tolower() nicht mehr ersetzen, damit kein endloser Aufruf
  226. #undef toupper
  227. #undef tolower
  228.  
  229. UBYTE mytoupper(unsigned long c)
  230. {
  231.     return (UBYTE) (UtilityBase ? ToUpper(c) : toupper(c));
  232. }
  233.  
  234. UBYTE mytolower(unsigned long c)
  235. {
  236.     return (UBYTE) (UtilityBase ? ToLower(c) : tolower(c));
  237. }
  238.  
  239.  
  240. #undef stricmp
  241. #undef strnicmp
  242.  
  243. LONG mystricmp(const char *string1, const char *string2 )
  244. {
  245.     ASSERT_VALID(string1);
  246.     ASSERT_VALID(string2);
  247.  
  248.     return UtilityBase ? Stricmp((STRPTR) string1, (STRPTR) string2) :
  249.         stricmp(string1, string2);
  250. }
  251.  
  252.  
  253. LONG mystrnicmp(const char *string1, const char *string2, long length )
  254. {
  255.     ASSERT_VALID(string1);
  256.     ASSERT_VALID(string2);
  257.  
  258.     return UtilityBase ? Strnicmp((STRPTR) string1, (STRPTR) string2, length)
  259.         : strnicmp(string1, string2, length);
  260. }
  261.  
  262.  
  263. void myFormatString(char *Buffer, const char *Format, ...)
  264. {
  265.     va_list Args;
  266.  
  267.     va_start(Args, Format);
  268.  
  269.     if (LocaleBase && LocaleBase->lib_Version>=38 && myLocale)
  270.         {
  271.         struct Hook myHook;
  272.  
  273.         myHook.h_Entry = (unsigned long (*)()) DateStrHook;
  274.         myHook.h_Data = Buffer;
  275.  
  276.         FormatString(myLocale, (STRPTR) Format, Args, &myHook);
  277.         }
  278.     else
  279.         {
  280.         // hier werden noch die %lU und %lD Formatanweisungen in Kleinbuchstaben umgesetzt,
  281.         // da sie von sprintf nicht erkannt werden.
  282.         char *FormatCopy;
  283.  
  284.         FormatCopy = strdup(Format);
  285.         if (FormatCopy)
  286.             {
  287.             char *p;
  288.  
  289.             p = strstr(Format, "%lU");
  290.             if (p)
  291.                 p[2] = 'u';
  292.  
  293.             p = strstr(Format, "%lD");
  294.             if (p)
  295.                 p[2] = 'd';
  296.  
  297.             vsprintf(Buffer, Format, Args);
  298.             free(FormatCopy);
  299.             }
  300.         }
  301.  
  302.     va_end(Args);
  303. }
  304.  
  305.